package org.TCC_NOVO.client.visual;

import com.google.gwt.user.client.rpc.AsyncCallback;
import com.gwtext.client.core.EventObject;
import com.gwtext.client.core.Position;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.Record;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.SimpleStore;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.widgets.Button;
import com.gwtext.client.widgets.MessageBox;
import com.gwtext.client.widgets.Panel;
import com.gwtext.client.widgets.TabPanel;
import com.gwtext.client.widgets.Window;
import com.gwtext.client.widgets.event.ButtonListenerAdapter;
import com.gwtext.client.widgets.form.ComboBox;
import com.gwtext.client.widgets.form.FormPanel;
import com.gwtext.client.widgets.form.NumberField;
import com.gwtext.client.widgets.form.TextArea;
import com.gwtext.client.widgets.form.TextField;
import com.gwtext.client.widgets.grid.ColumnConfig;
import com.gwtext.client.widgets.grid.ColumnModel;
import com.gwtext.client.widgets.grid.GridPanel;
import com.gwtext.client.widgets.grid.event.GridCellListenerAdapter;
import com.gwtext.client.widgets.layout.AnchorLayoutData;
import com.gwtext.client.widgets.layout.ColumnLayout;
import com.gwtext.client.widgets.layout.ColumnLayoutData;
import com.gwtext.client.widgets.layout.FormLayout;
import java.util.ArrayList;
import org.TCC_NOVO.client.modelo.Atividade;
import org.TCC_NOVO.client.modelo.Avaliacao;
import org.TCC_NOVO.client.modelo.Conteudo;
import org.TCC_NOVO.client.GWTServiceAsync;
import org.TCC_NOVO.client.modelo.Objetivo;
import org.TCC_NOVO.client.modelo.Unidade;

public class MatrizForm extends Window{

    private final GWTServiceAsync controller;
    MatrizPanelWindow matPanel;

    boolean edit;
    Record record;
    String ID_Form;
    Panel panelPrin;
    FormPanel formPanel;

    //Unidade
    TextField nomeUnid;
    TextArea DescUni;
    NumberField duracaoUnid;

    //Objetivos
    TextArea textAreaObj;
    GridPanel gridObj;
    Store storeObj;
    RecordDef recordDefObj;

    //Conteudos
    TextArea textAreaCont;
    GridPanel gridCont;
    Store storeCont;
    RecordDef recordDefCont;

    //Avaliacao
    TextArea textAreaAval;
    ComboBox CBTipo;
    GridPanel gridAval;
    Store storeAval;
    RecordDef recordDefAval;

    //Atividades
    TextArea textAreaAtiv;
    GridPanel gridAtiv;
    Store storeAtiv;
    RecordDef recordDefAtiv;

    public MatrizForm(MatrizPanelWindow matPanel, GWTServiceAsync controller) {
        this.controller = controller;
        this.matPanel = matPanel;
        this.setModal(true);
        this.setResizable(false);
        this.init();
    }

    private void init(){
        panelPrin = getPanelCentral();
        this.add(panelPrin);
        this.setTitle("Cadastro de Unidades de Aprendizagem");
    }

    private Panel getPanelCentral(){
        Panel panel = new Panel();
        panel.setBorder(false);
        panel.setPaddings(1);

        formPanel = new FormPanel();
        formPanel.setLabelAlign(Position.TOP);
        formPanel.setFrame(true);
        formPanel.setPaddings(5);
        formPanel.setWidth(800);

        Panel topPanel = new Panel();
        topPanel.setLayout(new ColumnLayout());
        topPanel.setBorder(false);

        Panel firstColumn = new Panel();
        firstColumn.setLayout(new FormLayout());
        firstColumn.setBorder(false);

        nomeUnid = new TextField("Nome", "nome");
        firstColumn.add(nomeUnid, new AnchorLayoutData("95%"));
        DescUni = new TextArea("Descrição", "descricao");
        firstColumn.add(DescUni, new AnchorLayoutData("95%"));
        duracaoUnid = new NumberField("Duração (minutos)", "duracao");
        duracaoUnid.setDecimalPrecision(0);
        firstColumn.add(duracaoUnid, new AnchorLayoutData("35%"));
        topPanel.add(firstColumn, new ColumnLayoutData(0.8));

        formPanel.add(topPanel);

        TabPanel tabPanel = new TabPanel();
        tabPanel.setPlain(true);
        tabPanel.setActiveTab(0);
        tabPanel.setHeight(365);

        //adiciona Tab Panel Objetivo...
        tabPanel.add(getPanelObjetivo());
        //adiciona Tab Panel Atividade...
        tabPanel.add(getPanelAtividade());
        //adiciona Tab Panel Conteudo...
        tabPanel.add(getPanelConteudo());
        //adiciona Tab Panel Avaliacao...
        tabPanel.add(getPanelAvaliacao());

        formPanel.add(tabPanel);

        final AsyncCallback callbackUnidade = new AsyncCallback() {
            public void onSuccess(Object result) {
                //MessageBox.alert("Registro Gravado com Sucesso!");
            }
            public void onFailure(Throwable caught) {
               MessageBox.alert("Erro ", caught.getMessage()); }
        };

        final Button save = new Button();
        save.setText(" Salvar");
        save.setIcon("Images/salvar.png");
        save.setTooltip("Salvar");
        save.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                Unidade Unid = getUnidadeForm();
                if (edit){
                    controller.AlterarDadosUnidade(Unid, callbackUnidade);                    
                    for (int i = 0; i < matPanel.arrayUnidades.size(); ++i) {
                        if (Integer.toString(matPanel.arrayUnidades.get(i).getId()).equals(ID_Form)) {
                            matPanel.arrayUnidades.remove(i);
                            matPanel.arrayUnidades.add(Unid);
                        }
                    }                    
                    hide();                    
                }else{
                    //Inclusao do registro no servidor (Banco de Dados)...
                    controller.GravarDadosUnidade(Unid, callbackUnidade);
                    salvarUnidade(Unid);
                    hide();
                }
                matPanel.CarregarGrid();
            }
        });
        formPanel.addButton(save);

        final Button cancel = new Button();
        cancel.setText(" Cancelar");
        cancel.setIcon("Images/cancelar.png");
        cancel.setTooltip("Cancelar");
        cancel.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                MessageBox.confirm("Deseja realmente sair?", "Todos os dados não submetidos serão perdidos", new MessageBox.ConfirmCallback() {
                    @Override
                    public void execute(String btnID) {
                        if (btnID.equals("yes")){
                            hide();
                        }
                        throw new UnsupportedOperationException("Not supported yet.");
                    }
                });
            }
        });
        formPanel.addButton(cancel);
        panel.add(formPanel);

        return panel;
    }

    private Unidade getUnidadeForm(){
        Unidade unid = new Unidade();
        if (edit){
           unid.setID(Integer.parseInt(ID_Form));
           unid.setAlteracao(true);           
        }
        unid.setStatus("Aberta");
        unid.setNome(nomeUnid.getText());        
        unid.setDescricao(DescUni.getText());
        unid.setDuracao(duracaoUnid.getText());
        unid.setIdf_projeto(matPanel.IDF_Proj);

        //objetivo
        ArrayList<Objetivo> arrayObj = new ArrayList();
        for (int i = 0; i < storeObj.getCount(); ++i) {
            Objetivo obj = new Objetivo();
            obj.setId(storeObj.getAt(i).getAsInteger("ID"));
            obj.setDescricao(storeObj.getAt(i).getAsString("descricaoObj"));
            obj.setAlteracao(edit);
            arrayObj.add(obj);
        }
        unid.setArrayObjetivo(arrayObj);

        //conteudo
        ArrayList<Conteudo> arrayCont = new ArrayList();
        for (int i = 0; i < storeCont.getCount(); ++i) {
            Conteudo cont = new Conteudo();
            cont.setId(storeCont.getAt(i).getAsInteger("ID"));
            cont.setDescricao(storeCont.getAt(i).getAsString("descricaoCont"));
            cont.setAlteracao(edit);
            arrayCont.add(cont);
        }
        unid.setArrayConteudo(arrayCont);

        //atividade
        ArrayList<Atividade> arrayAtiv = new ArrayList();
        for (int i = 0; i < storeAtiv.getCount(); ++i) {
            Atividade ativ = new Atividade();
            ativ.setId(storeAtiv.getAt(i).getAsInteger("ID"));
            ativ.setDescricao(storeAtiv.getAt(i).getAsString("descricaoAtiv"));
            arrayAtiv.add(ativ);
        }
        unid.setArrayAtividade(arrayAtiv);

        //avaliação
        ArrayList<Avaliacao> arrayAval = new ArrayList();
        for (int i = 0; i < storeAval.getCount(); ++i) {
            Avaliacao aval = new Avaliacao();
            aval.setId(storeAval.getAt(i).getAsInteger("ID"));
            aval.setTipo(storeAval.getAt(i).getAsString("instrumento"));
            aval.setDescricao(storeAval.getAt(i).getAsString("descricaoAval"));
            aval.setAlteracao(edit);
            arrayAval.add(aval);
        }
        unid.setArrayAvaliacao(arrayAval);

        return unid;
    }

    private void salvarUnidade(Unidade unid){
        this.matPanel.arrayUnidades.add(unid);
        this.matPanel.addRecord(unid, this.matPanel.UltNumero+1);
    }


    private Panel getPanelObjetivo(){
        
        Panel panelObjetivos = new Panel();
        panelObjetivos.setLayout(new ColumnLayout());
        panelObjetivos.setBorder(false);
        panelObjetivos.setTitle("Objetivos");

        Panel ObjetTab = new Panel();
        ObjetTab.setFrame(true);
        ObjetTab.setLayout(new FormLayout());
        ObjetTab.setPaddings(10);
        ObjetTab.setHeight(335);

        textAreaObj = new TextArea("Descrição", "descricaoObj");
        textAreaObj.setSize(236, 245);
        ObjetTab.add(textAreaObj);

        final Button AdicionaObj = new Button();
        AdicionaObj.setText(" Salvar");
        AdicionaObj.setIcon("Images/adicionarGrid.png");
        AdicionaObj.setTooltip("Salva no grid as informações");
        AdicionaObj.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                //se nao tiver nenhum registro selecionado no grid em inclui um novo regsitro
                Objetivo Objetivo = getObjetivoForm();
                if (gridObj.getSelectionModel().getSelected() == null){
                    if (!textAreaObj.getText().equals("")){                        
                        addRecordObjetivo(Objetivo);
                        LimparObjetivo();
                    }else{
                        MessageBox.alert("Necessário informar uma descrição ao objetivo");
                    }
                }else{//senao altera o existente
                    gridObj.getSelectionModel().getSelected().set("descricaoObj", Objetivo.getDescricao());
                    gridObj.getSelectionModel().deselectRange(0,50);
                    LimparObjetivo();
                }
            }
        });

        final Button removerObj = new Button();
        removerObj.setText(" Remover");
        removerObj.setIcon("Images/removerGrid.png");
        removerObj.setTooltip("Remove do grid o item selecionado");
        removerObj.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                if (gridObj.getSelectionModel().getSelected() == null){
                    MessageBox.alert("Necessário Selecionar Algum Registro! ");
                }else {
                    MessageBox.confirm("Confirmação de Exclusão", "Deseja Realmente Remover o Registro?", new MessageBox.ConfirmCallback(){
                    public void execute(String btnID){
                        if (btnID.equals("yes")){
                            //Remoção do Registro no Cliente (Grid)...
                            removeObjetivo();
                        }
                    }});
                }
            }
        });

        ObjetTab.addButton(AdicionaObj);
        ObjetTab.addButton(removerObj);
        panelObjetivos.add(ObjetTab, new ColumnLayoutData(0.35));

        recordDefObj = new RecordDef(new FieldDef[]{
            new IntegerFieldDef("ID"),
            new StringFieldDef("descricaoObj"),
        });

        storeObj = new Store(recordDefObj);

        gridObj = new GridPanel();
        gridObj.setStore(storeObj);

        ColumnConfig[] columnsObj = new ColumnConfig[]{
            new ColumnConfig("Descrição", "descricaoObj", 360, true),
        };

        ColumnModel columnModel = new ColumnModel(columnsObj);
        gridObj.setColumnModel(columnModel);
        gridObj.setFrame(true);
        gridObj.setStripeRows(true);
        gridObj.setSize(600, 600);
        gridObj.setAutoScroll(true);
        gridObj.addGridCellListener(new GridCellListenerAdapter() {
            public void onCellDblClick(GridPanel grid, int rowIndex, int colIndex, EventObject e) {
                textAreaObj.setValue(grid.getSelectionModel().getSelected().getAsString("descricaoObj"));
            }
        });

        panelObjetivos.add(gridObj, new ColumnLayoutData(0.65));

        return panelObjetivos;
    }

    public void addRecordObjetivo(Objetivo Objet){
        Object[] rowData = new Object[]{
          Objet.getId(),
          Objet.getDescricao(),
        };
        Record recordLoc = recordDefObj.createRecord(/*rowData[0].toString(), */rowData);
        storeObj.add(recordLoc);
    }

    private void removeObjetivo(){
        storeObj.remove(gridObj.getSelectionModel().getSelected());
    }

    private Objetivo getObjetivoForm(){
        Objetivo Obj = new Objetivo();
        Obj.setAlteracao(edit);
        Obj.setDescricao(textAreaObj.getText());
        return Obj;
    }

    private void LimparObjetivo(){
        textAreaObj.setValue("");
    }

    public void addRecordConteudo(Conteudo Cont){
        Object[] rowData = new Object[]{
          Cont.getId(),
          Cont.getDescricao(),
        };
        Record recordLoc = recordDefCont.createRecord(/*rowData[0].toString(), */rowData);
        storeCont.add(recordLoc);
    }

    private void removeConteudo(){
        storeCont.remove(gridCont.getSelectionModel().getSelected());
    }

    private Conteudo getConteudoForm(){
        Conteudo Cont = new Conteudo();
        Cont.setDescricao(textAreaCont.getText());
        Cont.setAlteracao(edit);
        return Cont;
    }

    private void LimparConteudo(){
        textAreaCont.setValue("");
    }

    private Panel getPanelConteudo(){

        Panel panelConteudos = new Panel();
        panelConteudos.setLayout(new ColumnLayout());
        panelConteudos.setBorder(false);
        panelConteudos.setTitle("Conteúdos");

        Panel ContTab = new Panel();
        ContTab.setFrame(true);
        ContTab.setLayout(new FormLayout());
        ContTab.setPaddings(10);
        ContTab.setHeight(335);

        textAreaCont = new TextArea("Descrição", "descricaoCont");
        textAreaCont.setSize(236, 245);
        ContTab.add(textAreaCont);

        final Button AdicionaCont = new Button();
        AdicionaCont.setText(" Salvar");
        AdicionaCont.setIcon("Images/adicionarGrid.png");
        AdicionaCont.setTooltip("Adiciona no grid as informações");
        AdicionaCont.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                Conteudo conteudo = getConteudoForm();
                if (gridCont.getSelectionModel().getSelected() == null){
                    if (!textAreaCont.getText().equals("")){                        
                        addRecordConteudo(conteudo);
                        LimparConteudo();
                    }else{
                        MessageBox.alert("Necessário informar uma descrição!");
                    }
                }else{//senao altera o existente
                    gridCont.getSelectionModel().getSelected().set("descricaoCont", conteudo.getDescricao());
                    gridCont.getSelectionModel().deselectRange(0,50);
                    LimparConteudo();
                }
            }
        });

        final Button removerCont = new Button();
        removerCont.setText(" Remover");
        removerCont.setIcon("Images/removerGrid.png");
        removerCont.setTooltip("Remove do grid o item selecionado");
        removerCont.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                if (gridCont.getSelectionModel().getSelected() == null){
                    MessageBox.alert("Necessário Selecionar Algum Registro! ");
                }else {
                    MessageBox.confirm("Confirmação de Exclusão", "Deseja Realmente Remover o Registro?", new MessageBox.ConfirmCallback(){
                    public void execute(String btnID){
                        if (btnID.equals("yes")){
                            //Remoção do Registro no Cliente (Grid)...
                            removeConteudo();
                        }
                    }});
                }
            }
        });

        ContTab.addButton(AdicionaCont);
        ContTab.addButton(removerCont);
        panelConteudos.add(ContTab, new ColumnLayoutData(0.35));

        recordDefCont = new RecordDef(new FieldDef[]{
            new IntegerFieldDef("ID"),
            new StringFieldDef("descricaoCont"),
        });

        storeCont = new Store(recordDefCont);

        gridCont = new GridPanel();
        gridCont.setStore(storeCont);

        ColumnConfig[] columnsCont = new ColumnConfig[]{
            new ColumnConfig("Descrição", "descricaoCont", 360, true),
        };

        ColumnModel columnModel = new ColumnModel(columnsCont);
        gridCont.setColumnModel(columnModel);
        gridCont.setFrame(true);
        gridCont.setStripeRows(true);
        gridCont.setSize(600, 600);
        gridCont.setAutoScroll(true);
        gridCont.addGridCellListener(new GridCellListenerAdapter() {
            public void onCellDblClick(GridPanel grid, int rowIndex, int colIndex, EventObject e) {
                textAreaCont.setValue(grid.getSelectionModel().getSelected().getAsString("descricaoCont"));
            }
        });

        panelConteudos.add(gridCont, new ColumnLayoutData(0.65));

        return panelConteudos;
    }

    public void addRecordAvaliacao(Avaliacao Aval){
        Object[] rowData = new Object[]{
          Aval.getId(),
          Aval.getTipo(),
          Aval.getDescricao(),
        };
        Record recordLoc = recordDefAval.createRecord(rowData);
        storeAval.add(recordLoc);
    }

    private void removeAvaliacao(){
        storeAval.remove(gridAval.getSelectionModel().getSelected());
    }

    private Avaliacao getAvaliacaoForm(){
        Avaliacao Aval = new Avaliacao();
        Aval.setDescricao(textAreaAval.getText());
        Aval.setTipo(CBTipo.getRawValue());
        Aval.setAlteracao(edit);
        return Aval;
    }

    private void LimparAvaliacao(){
        textAreaAval.setValue("");
    }


    private Panel getPanelAvaliacao(){

        Panel panelAvaliacao = new Panel();
        panelAvaliacao.setLayout(new ColumnLayout());
        panelAvaliacao.setBorder(false);
        panelAvaliacao.setTitle("Avaliação");

        Panel AvalTab = new Panel();
        AvalTab.setFrame(true);
        AvalTab.setLayout(new FormLayout());
        AvalTab.setPaddings(10);
        AvalTab.setHeight(335);

        int ID = 0;
        final Store store = new SimpleStore(ID, new String[]{"ID", "instrumento"}, getTiposDescricao());
        store.load();

        CBTipo = new ComboBox();
        CBTipo.setForceSelection(true);
        CBTipo.setMinChars(1);
        CBTipo.setFieldLabel("Instrumentos de Avaliação");
        CBTipo.setStore(store);
        CBTipo.setDisplayField("instrumento");
        CBTipo.setValueField("ID");
        CBTipo.setMode(ComboBox.LOCAL);
        CBTipo.setTriggerAction(ComboBox.ALL);
        CBTipo.setEmptyText("Selecione o Instrumento de Avaliação");
        CBTipo.setLoadingText("Searching...");
        CBTipo.setTypeAhead(true);
        CBTipo.setSelectOnFocus(true);
        CBTipo.setWidth(236);
        CBTipo.setHideTrigger(false);
        CBTipo.setName("instrumento");
        AvalTab.add(CBTipo);

        textAreaAval = new TextArea("Descrição", "descricaoAval");
        textAreaAval.setSize(236, 190);
        AvalTab.add(textAreaAval);

        final Button AdicionaAval = new Button();
        AdicionaAval.setText(" Salvar");
        AdicionaAval.setIcon("Images/adicionarGrid.png");
        AdicionaAval.setTooltip("Adiciona no grid as informações");
        AdicionaAval.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                Avaliacao aval = getAvaliacaoForm();
                if (gridAval.getSelectionModel().getSelected() == null){
                    if (!CBTipo.getText().equals("")){                        
                        addRecordAvaliacao(aval);
                        LimparAvaliacao();
                    }else{
                        MessageBox.alert("Necessário informar um Tipo de Avaliacão!");
                    }
                }else{
                    gridAval.getSelectionModel().getSelected().set("descricaoAval", aval.getDescricao());
                    gridAval.getSelectionModel().getSelected().set("instrumento", aval.getTipo());
                    gridAval.getSelectionModel().deselectRange(0,50);
                    LimparAvaliacao();
                }
            }
        });

        final Button removerAval = new Button();
        removerAval.setText(" Remover");
        removerAval.setIcon("Images/removerGrid.png");
        removerAval.setTooltip("Remove do grid o item selecionado");
        removerAval.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                if (gridAval.getSelectionModel().getSelected() == null){
                    MessageBox.alert("Necessário Selecionar Algum Registro! ");
                }else {
                    MessageBox.confirm("Confirmação de Exclusão", "Deseja Realmente Remover o Registro?", new MessageBox.ConfirmCallback(){
                    public void execute(String btnID){
                        if (btnID.equals("yes")){
                            //Remoção do Registro no Cliente (Grid)...
                            removeAvaliacao();
                        }
                    }});
                }
            }
        });

        AvalTab.addButton(AdicionaAval);
        AvalTab.addButton(removerAval);
        panelAvaliacao.add(AvalTab, new ColumnLayoutData(0.35));

        recordDefAval = new RecordDef(new FieldDef[]{
            new IntegerFieldDef("ID"),
            new StringFieldDef("instrumento"),
            new StringFieldDef("descricaoAval"),
        });

        storeAval = new Store(recordDefAval);

        gridAval = new GridPanel();
        gridAval.setStore(storeAval);

        ColumnConfig[] columnsAval = new ColumnConfig[]{
            new ColumnConfig("Instrumento de Aval.", "instrumento", 180, true),
            new ColumnConfig("Descrição", "descricaoAval", 300, true),
        };

        ColumnModel columnModel = new ColumnModel(columnsAval);
        gridAval.setColumnModel(columnModel);
        gridAval.setFrame(true);
        gridAval.setStripeRows(true);
        gridAval.setSize(600, 600);
        gridAval.setAutoScroll(true);
        gridAval.addGridCellListener(new GridCellListenerAdapter() {
            @Override
            public void onCellDblClick(GridPanel grid, int rowIndex, int colIndex, EventObject e) {
                textAreaAval.setValue(grid.getSelectionModel().getSelected().getAsString("descricaoAval"));
                CBTipo.setValue(grid.getSelectionModel().getSelected().getAsString("instrumento"));
            }
        });

        panelAvaliacao.add(gridAval, new ColumnLayoutData(0.65));

        return panelAvaliacao;
    }

    private Panel getPanelAtividade(){

        Panel panelAtividades = new Panel();
        panelAtividades.setLayout(new ColumnLayout());
        panelAtividades.setBorder(false);
        panelAtividades.setTitle("Atividades");

        Panel AtivTab = new Panel();
        AtivTab.setFrame(true);
        AtivTab.setLayout(new FormLayout());
        AtivTab.setPaddings(10);
        AtivTab.setHeight(335);

        textAreaAtiv = new TextArea("Descrição", "descricaoAtiv");
        textAreaAtiv.setSize(236, 245);
        AtivTab.add(textAreaAtiv);

        final Button AdicionaAtiv = new Button();
        AdicionaAtiv.setText(" Salvar");
        AdicionaAtiv.setIcon("Images/adicionarGrid.png");
        AdicionaAtiv.setTooltip("Adiciona no grid as informações");
        AdicionaAtiv.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                Atividade atividade = getAtividadeForm();
                if (gridAtiv.getSelectionModel().getSelected() == null){
                    if (!textAreaAtiv.getText().equals("")){                        
                        addRecordAtividade(atividade);
                        LimparAtividade();
                    }else{
                        MessageBox.alert("Necessário informar uma descrição ao objetivo");
                    }
                }else{
                    gridAtiv.getSelectionModel().getSelected().set("descricaoAtiv", atividade.getDescricao());
                    gridAtiv.getSelectionModel().deselectRange(0,50);
                    LimparAtividade();
                }
            }
        });

        final Button removerAtiv = new Button();
        removerAtiv.setText(" Remover");
        removerAtiv.setIcon("Images/removerGrid.png");
        removerAtiv.setTooltip("Remove do grid o item selecionado");
        removerAtiv.addListener(new ButtonListenerAdapter(){
            public void onClick(Button button, EventObject e){
                if (gridAtiv.getSelectionModel().getSelected() == null){
                    MessageBox.alert("Necessário Selecionar Algum Registro! ");
                }else {
                    MessageBox.confirm("Confirmação de Exclusão", "Deseja Realmente Remover o Registro?", new MessageBox.ConfirmCallback(){
                    public void execute(String btnID){
                        if (btnID.equals("yes")){
                            //Remoção do Registro no Cliente (Grid)...
                            removeAtividade();
                        }
                    }});
                }
            }
        });

        AtivTab.addButton(AdicionaAtiv);
        AtivTab.addButton(removerAtiv);
        panelAtividades.add(AtivTab, new ColumnLayoutData(0.35));

        recordDefAtiv = new RecordDef(new FieldDef[]{
            new IntegerFieldDef("ID"),
            new StringFieldDef("descricaoAtiv"),
        });

        storeAtiv = new Store(recordDefAtiv);

        gridAtiv = new GridPanel();
        gridAtiv.setStore(storeAtiv);

        ColumnConfig[] columnsAtiv = new ColumnConfig[]{
            new ColumnConfig("Descrição", "descricaoAtiv", 360, true),
        };

        ColumnModel columnModel = new ColumnModel(columnsAtiv);
        gridAtiv.setColumnModel(columnModel);
        gridAtiv.setFrame(true);
        gridAtiv.setStripeRows(true);
        gridAtiv.setSize(600, 600);
        gridAtiv.setAutoScroll(true);
        gridAtiv.addGridCellListener(new GridCellListenerAdapter() {
            public void onCellDblClick(GridPanel grid, int rowIndex, int colIndex, EventObject e) {
                textAreaAtiv.setValue(grid.getSelectionModel().getSelected().getAsString("descricaoAtiv"));
            }
        });

        panelAtividades.add(gridAtiv, new ColumnLayoutData(0.65));

        return panelAtividades;
    }

    public void addRecordAtividade(Atividade Ativ){
        Object[] rowData = new Object[]{
          Ativ.getId(),
          Ativ.getDescricao(),
        };
        Record recordLoc = recordDefAtiv.createRecord(rowData);
        storeAtiv.add(recordLoc);
    }

    private void removeAtividade(){
        storeAtiv.remove(gridAtiv.getSelectionModel().getSelected());
    }

    private Atividade getAtividadeForm(){
        Atividade Ativ = new Atividade();
        Ativ.setDescricao(textAreaAtiv.getText());
        return Ativ;
    }

    private void LimparAtividade(){
        textAreaAtiv.setValue("");
    }


    public void show(boolean edit){
        this.edit = edit;
        if (edit){
            initEdit();
        }else{
            initNew();
        }
        show();
    }

    private void initEdit(){
        nomeUnid.focus();
    }

    private void initNew(){
        limparUnidadeGeral();
    }

    public void limparUnidadeGeral(){
        ID_Form = "";
        nomeUnid.setValue("");
        DescUni.setValue("");
        duracaoUnid.setValue("");
        storeObj.removeAll();
        storeCont.removeAll();
        storeAval.removeAll();
        storeAtiv.removeAll();
    }

    public void loadRecord(Unidade unid){
        ID_Form = Integer.toString(unid.getId());
        nomeUnid.setValue(unid.getNome());
        DescUni.setValue(unid.getDescricao());
        duracaoUnid.setValue(unid.getDuracao());

        //preenche o grid com as atividades daquela unidade
        for (int i = 0; i < unid.getArrayAtividade().size(); ++i) {
            Atividade ativ = unid.getArrayAtividade().get(i);
            addRecordAtividade(ativ);
        }

        //preenche o grid com as avaliacoes daquela unidade
        for (int i = 0; i < unid.getArrayAvaliacao().size(); ++i) {
            Avaliacao aval = unid.getArrayAvaliacao().get(i);
            addRecordAvaliacao(aval);
        }

        //preenche o grid com os objetivos daquela unidade
        for (int i = 0; i < unid.getArrayObjetivo().size(); ++i) {
            Objetivo obj = unid.getArrayObjetivo().get(i);
            addRecordObjetivo(obj);
        }

        //preenche o grid com os conteudos daquela unidade
        for (int i = 0; i < unid.getArrayConteudo().size(); ++i) {
            Conteudo cont = unid.getArrayConteudo().get(i);
            addRecordConteudo(cont);
        }
    }

    private String[][] getTiposDescricao() {
        String[][] str = new String[][]{};

        str = new String[][]{
                new String[]{"77", "Testes de múltipla escolha"},
                new String[]{"78", "Testes de verdadeiro/falso"},
                new String[]{"79", "Testes de associação"},
                new String[]{"80", "Testes de preenchimento de lacunas"},
                new String[]{"81", "Testes de arrastar-e-soltar"},
                new String[]{"187", "Puzzles"},
                new String[]{"188", "Questões dissertativas"},
                new String[]{"189", "Questões de resolução de problemas"},
                new String[]{"190", "Rubricas"},
                new String[]{"191", "Portfólios"},
                new String[]{"192", "Auto-avaliação"},
                new String[]{"193", "Monitoramento automático"},
        };

        return str;
    }

}
